home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / hrtimer.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  14.4 KB  |  503 lines
  1. /*
  2.  *  include/linux/hrtimer.h
  3.  *
  4.  *  hrtimers - High-resolution kernel timers
  5.  *
  6.  *   Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
  7.  *   Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
  8.  *
  9.  *  data type definitions, declarations, prototypes
  10.  *
  11.  *  Started by: Thomas Gleixner and Ingo Molnar
  12.  *
  13.  *  For licencing details see kernel-base/COPYING
  14.  */
  15. #ifndef _LINUX_HRTIMER_H
  16. #define _LINUX_HRTIMER_H
  17.  
  18. #include <linux/rbtree.h>
  19. #include <linux/ktime.h>
  20. #include <linux/init.h>
  21. #include <linux/list.h>
  22. #include <linux/wait.h>
  23. #include <linux/percpu.h>
  24.  
  25.  
  26. struct hrtimer_clock_base;
  27. struct hrtimer_cpu_base;
  28.  
  29. /*
  30.  * Mode arguments of xxx_hrtimer functions:
  31.  */
  32. enum hrtimer_mode {
  33.     HRTIMER_MODE_ABS,    /* Time value is absolute */
  34.     HRTIMER_MODE_REL,    /* Time value is relative to now */
  35. };
  36.  
  37. /*
  38.  * Return values for the callback function
  39.  */
  40. enum hrtimer_restart {
  41.     HRTIMER_NORESTART,    /* Timer is not restarted */
  42.     HRTIMER_RESTART,    /* Timer must be restarted */
  43. };
  44.  
  45. /*
  46.  * hrtimer callback modes:
  47.  *
  48.  *    HRTIMER_CB_SOFTIRQ:        Callback must run in softirq context
  49.  *    HRTIMER_CB_IRQSAFE_PERCPU:    Callback must run in hardirq context
  50.  *                    Special mode for tick emulation and
  51.  *                    scheduler timer. Such timers are per
  52.  *                    cpu and not allowed to be migrated on
  53.  *                    cpu unplug.
  54.  *    HRTIMER_CB_IRQSAFE_UNLOCKED:    Callback should run in hardirq context
  55.  *                    with timer->base lock unlocked
  56.  *                    used for timers which call wakeup to
  57.  *                    avoid lock order problems with rq->lock
  58.  */
  59. enum hrtimer_cb_mode {
  60.     HRTIMER_CB_SOFTIRQ,
  61.     HRTIMER_CB_IRQSAFE_PERCPU,
  62.     HRTIMER_CB_IRQSAFE_UNLOCKED,
  63. };
  64.  
  65. /*
  66.  * Values to track state of the timer
  67.  *
  68.  * Possible states:
  69.  *
  70.  * 0x00        inactive
  71.  * 0x01        enqueued into rbtree
  72.  * 0x02        callback function running
  73.  * 0x04        callback pending (high resolution mode)
  74.  *
  75.  * Special cases:
  76.  * 0x03        callback function running and enqueued
  77.  *        (was requeued on another CPU)
  78.  * 0x09        timer was migrated on CPU hotunplug
  79.  * The "callback function running and enqueued" status is only possible on
  80.  * SMP. It happens for example when a posix timer expired and the callback
  81.  * queued a signal. Between dropping the lock which protects the posix timer
  82.  * and reacquiring the base lock of the hrtimer, another CPU can deliver the
  83.  * signal and rearm the timer. We have to preserve the callback running state,
  84.  * as otherwise the timer could be removed before the softirq code finishes the
  85.  * the handling of the timer.
  86.  *
  87.  * The HRTIMER_STATE_ENQUEUED bit is always or'ed to the current state to
  88.  * preserve the HRTIMER_STATE_CALLBACK bit in the above scenario.
  89.  *
  90.  * All state transitions are protected by cpu_base->lock.
  91.  */
  92. #define HRTIMER_STATE_INACTIVE    0x00
  93. #define HRTIMER_STATE_ENQUEUED    0x01
  94. #define HRTIMER_STATE_CALLBACK    0x02
  95. #define HRTIMER_STATE_PENDING    0x04
  96. #define HRTIMER_STATE_MIGRATE    0x08
  97.  
  98. /**
  99.  * struct hrtimer - the basic hrtimer structure
  100.  * @node:    red black tree node for time ordered insertion
  101.  * @_expires:    the absolute expiry time in the hrtimers internal
  102.  *        representation. The time is related to the clock on
  103.  *        which the timer is based. Is setup by adding
  104.  *        slack to the _softexpires value. For non range timers
  105.  *        identical to _softexpires.
  106.  * @_softexpires: the absolute earliest expiry time of the hrtimer.
  107.  *        The time which was given as expiry time when the timer
  108.  *        was armed.
  109.  * @function:    timer expiry callback function
  110.  * @base:    pointer to the timer base (per cpu and per clock)
  111.  * @state:    state information (See bit values above)
  112.  * @cb_mode:    high resolution timer feature to select the callback execution
  113.  *         mode
  114.  * @cb_entry:    list head to enqueue an expired timer into the callback list
  115.  * @start_site:    timer statistics field to store the site where the timer
  116.  *        was started
  117.  * @start_comm: timer statistics field to store the name of the process which
  118.  *        started the timer
  119.  * @start_pid: timer statistics field to store the pid of the task which
  120.  *        started the timer
  121.  *
  122.  * The hrtimer structure must be initialized by hrtimer_init()
  123.  */
  124. struct hrtimer {
  125.     struct rb_node            node;
  126.     ktime_t                _expires;
  127.     ktime_t                _softexpires;
  128.     enum hrtimer_restart        (*function)(struct hrtimer *);
  129.     struct hrtimer_clock_base    *base;
  130.     unsigned long            state;
  131.     struct list_head        cb_entry;
  132.     enum hrtimer_cb_mode        cb_mode;
  133. #ifdef CONFIG_TIMER_STATS
  134.     int                start_pid;
  135.     void                *start_site;
  136.     char                start_comm[16];
  137. #endif
  138. };
  139.  
  140. /**
  141.  * struct hrtimer_sleeper - simple sleeper structure
  142.  * @timer:    embedded timer structure
  143.  * @task:    task to wake up
  144.  *
  145.  * task is set to NULL, when the timer expires.
  146.  */
  147. struct hrtimer_sleeper {
  148.     struct hrtimer timer;
  149.     struct task_struct *task;
  150. };
  151.  
  152. /**
  153.  * struct hrtimer_clock_base - the timer base for a specific clock
  154.  * @cpu_base:        per cpu clock base
  155.  * @index:        clock type index for per_cpu support when moving a
  156.  *            timer to a base on another cpu.
  157.  * @active:        red black tree root node for the active timers
  158.  * @first:        pointer to the timer node which expires first
  159.  * @resolution:        the resolution of the clock, in nanoseconds
  160.  * @get_time:        function to retrieve the current time of the clock
  161.  * @softirq_time:    the time when running the hrtimer queue in the softirq
  162.  * @offset:        offset of this clock to the monotonic base
  163.  */
  164. struct hrtimer_clock_base {
  165.     struct hrtimer_cpu_base    *cpu_base;
  166.     clockid_t        index;
  167.     struct rb_root        active;
  168.     struct rb_node        *first;
  169.     ktime_t            resolution;
  170.     ktime_t            (*get_time)(void);
  171.     ktime_t            softirq_time;
  172. #ifdef CONFIG_HIGH_RES_TIMERS
  173.     ktime_t            offset;
  174. #endif
  175. };
  176.  
  177. #define HRTIMER_MAX_CLOCK_BASES 2
  178.  
  179. /*
  180.  * struct hrtimer_cpu_base - the per cpu clock bases
  181.  * @lock:        lock protecting the base and associated clock bases
  182.  *            and timers
  183.  * @clock_base:        array of clock bases for this cpu
  184.  * @curr_timer:        the timer which is executing a callback right now
  185.  * @expires_next:    absolute time of the next event which was scheduled
  186.  *            via clock_set_next_event()
  187.  * @hres_active:    State of high resolution mode
  188.  * @check_clocks:    Indictator, when set evaluate time source and clock
  189.  *            event devices whether high resolution mode can be
  190.  *            activated.
  191.  * @cb_pending:        Expired timers are moved from the rbtree to this
  192.  *            list in the timer interrupt. The list is processed
  193.  *            in the softirq.
  194.  * @nr_events:        Total number of timer interrupt events
  195.  */
  196. struct hrtimer_cpu_base {
  197.     spinlock_t            lock;
  198.     struct hrtimer_clock_base    clock_base[HRTIMER_MAX_CLOCK_BASES];
  199.     struct list_head        cb_pending;
  200. #ifdef CONFIG_HIGH_RES_TIMERS
  201.     ktime_t                expires_next;
  202.     int                hres_active;
  203.     unsigned long            nr_events;
  204. #endif
  205. };
  206.  
  207. static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
  208. {
  209.     timer->_expires = time;
  210.     timer->_softexpires = time;
  211. }
  212.  
  213. static inline void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
  214. {
  215.     timer->_softexpires = time;
  216.     timer->_expires = ktime_add_safe(time, delta);
  217. }
  218.  
  219. static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, unsigned long delta)
  220. {
  221.     timer->_softexpires = time;
  222.     timer->_expires = ktime_add_safe(time, ns_to_ktime(delta));
  223. }
  224.  
  225. static inline void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
  226. {
  227.     timer->_expires.tv64 = tv64;
  228.     timer->_softexpires.tv64 = tv64;
  229. }
  230.  
  231. static inline void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
  232. {
  233.     timer->_expires = ktime_add_safe(timer->_expires, time);
  234.     timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
  235. }
  236.  
  237. static inline void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
  238. {
  239.     timer->_expires = ktime_add_ns(timer->_expires, ns);
  240.     timer->_softexpires = ktime_add_ns(timer->_softexpires, ns);
  241. }
  242.  
  243. static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer)
  244. {
  245.     return timer->_expires;
  246. }
  247.  
  248. static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
  249. {
  250.     return timer->_softexpires;
  251. }
  252.  
  253. static inline s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
  254. {
  255.     return timer->_expires.tv64;
  256. }
  257. static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
  258. {
  259.     return timer->_softexpires.tv64;
  260. }
  261.  
  262. static inline s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
  263. {
  264.     return ktime_to_ns(timer->_expires);
  265. }
  266.  
  267. static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
  268. {
  269.     return ktime_sub(timer->_expires, timer->base->get_time());
  270. }
  271.  
  272. #ifdef CONFIG_HIGH_RES_TIMERS
  273. struct clock_event_device;
  274.  
  275. extern void clock_was_set(void);
  276. extern void hres_timers_resume(void);
  277. extern void hrtimer_interrupt(struct clock_event_device *dev);
  278.  
  279. /*
  280.  * In high resolution mode the time reference must be read accurate
  281.  */
  282. static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
  283. {
  284.     return timer->base->get_time();
  285. }
  286.  
  287. static inline int hrtimer_is_hres_active(struct hrtimer *timer)
  288. {
  289.     return timer->base->cpu_base->hres_active;
  290. }
  291.  
  292. extern void hrtimer_peek_ahead_timers(void);
  293.  
  294. /*
  295.  * The resolution of the clocks. The resolution value is returned in
  296.  * the clock_getres() system call to give application programmers an
  297.  * idea of the (in)accuracy of timers. Timer values are rounded up to
  298.  * this resolution values.
  299.  */
  300. # define HIGH_RES_NSEC        1
  301. # define KTIME_HIGH_RES        (ktime_t) { .tv64 = HIGH_RES_NSEC }
  302. # define MONOTONIC_RES_NSEC    HIGH_RES_NSEC
  303. # define KTIME_MONOTONIC_RES    KTIME_HIGH_RES
  304.  
  305. #else
  306.  
  307. # define MONOTONIC_RES_NSEC    LOW_RES_NSEC
  308. # define KTIME_MONOTONIC_RES    KTIME_LOW_RES
  309.  
  310. /*
  311.  * clock_was_set() is a NOP for non- high-resolution systems. The
  312.  * time-sorted order guarantees that a timer does not expire early and
  313.  * is expired in the next softirq when the clock was advanced.
  314.  */
  315. static inline void clock_was_set(void) { }
  316. static inline void hrtimer_peek_ahead_timers(void) { }
  317.  
  318. static inline void hres_timers_resume(void) { }
  319.  
  320. /*
  321.  * In non high resolution mode the time reference is taken from
  322.  * the base softirq time variable.
  323.  */
  324. static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
  325. {
  326.     return timer->base->softirq_time;
  327. }
  328.  
  329. static inline int hrtimer_is_hres_active(struct hrtimer *timer)
  330. {
  331.     return 0;
  332. }
  333. #endif
  334.  
  335. extern ktime_t ktime_get(void);
  336. extern ktime_t ktime_get_real(void);
  337.  
  338.  
  339. DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
  340.  
  341.  
  342. /* Exported timer functions: */
  343.  
  344. /* Initialize timers: */
  345. extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
  346.              enum hrtimer_mode mode);
  347.  
  348. #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
  349. extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,
  350.                   enum hrtimer_mode mode);
  351.  
  352. extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
  353. #else
  354. static inline void hrtimer_init_on_stack(struct hrtimer *timer,
  355.                      clockid_t which_clock,
  356.                      enum hrtimer_mode mode)
  357. {
  358.     hrtimer_init(timer, which_clock, mode);
  359. }
  360. static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
  361. #endif
  362.  
  363. /* Basic timer operations: */
  364. extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
  365.              const enum hrtimer_mode mode);
  366. extern int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
  367.             unsigned long range_ns, const enum hrtimer_mode mode);
  368. extern int hrtimer_cancel(struct hrtimer *timer);
  369. extern int hrtimer_try_to_cancel(struct hrtimer *timer);
  370.  
  371. static inline int hrtimer_start_expires(struct hrtimer *timer,
  372.                         enum hrtimer_mode mode)
  373. {
  374.     unsigned long delta;
  375.     ktime_t soft, hard;
  376.     soft = hrtimer_get_softexpires(timer);
  377.     hard = hrtimer_get_expires(timer);
  378.     delta = ktime_to_ns(ktime_sub(hard, soft));
  379.     return hrtimer_start_range_ns(timer, soft, delta, mode);
  380. }
  381.  
  382. static inline int hrtimer_restart(struct hrtimer *timer)
  383. {
  384.     return hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
  385. }
  386.  
  387. /* Query timers: */
  388. extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
  389. extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
  390.  
  391. extern ktime_t hrtimer_get_next_event(void);
  392.  
  393. /*
  394.  * A timer is active, when it is enqueued into the rbtree or the callback
  395.  * function is running.
  396.  */
  397. static inline int hrtimer_active(const struct hrtimer *timer)
  398. {
  399.     return timer->state != HRTIMER_STATE_INACTIVE;
  400. }
  401.  
  402. /*
  403.  * Helper function to check, whether the timer is on one of the queues
  404.  */
  405. static inline int hrtimer_is_queued(struct hrtimer *timer)
  406. {
  407.     return timer->state &
  408.         (HRTIMER_STATE_ENQUEUED | HRTIMER_STATE_PENDING);
  409. }
  410.  
  411. /*
  412.  * Helper function to check, whether the timer is running the callback
  413.  * function
  414.  */
  415. static inline int hrtimer_callback_running(struct hrtimer *timer)
  416. {
  417.     return timer->state & HRTIMER_STATE_CALLBACK;
  418. }
  419.  
  420. /* Forward a hrtimer so it expires after now: */
  421. extern u64
  422. hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
  423.  
  424. /* Forward a hrtimer so it expires after the hrtimer's current now */
  425. static inline u64 hrtimer_forward_now(struct hrtimer *timer,
  426.                       ktime_t interval)
  427. {
  428.     return hrtimer_forward(timer, timer->base->get_time(), interval);
  429. }
  430.  
  431. /* Precise sleep: */
  432. extern long hrtimer_nanosleep(struct timespec *rqtp,
  433.                   struct timespec __user *rmtp,
  434.                   const enum hrtimer_mode mode,
  435.                   const clockid_t clockid);
  436. extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);
  437.  
  438. extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
  439.                  struct task_struct *tsk);
  440.  
  441. extern int schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
  442.                         const enum hrtimer_mode mode);
  443. extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
  444.  
  445. /* Soft interrupt function to run the hrtimer queues: */
  446. extern void hrtimer_run_queues(void);
  447. extern void hrtimer_run_pending(void);
  448.  
  449. /* Bootup initialization: */
  450. extern void __init hrtimers_init(void);
  451.  
  452. #if BITS_PER_LONG < 64
  453. extern u64 ktime_divns(const ktime_t kt, s64 div);
  454. #else /* BITS_PER_LONG < 64 */
  455. # define ktime_divns(kt, div)        (u64)((kt).tv64 / (div))
  456. #endif
  457.  
  458. /* Show pending timers: */
  459. extern void sysrq_timer_list_show(void);
  460.  
  461. /*
  462.  * Timer-statistics info:
  463.  */
  464. #ifdef CONFIG_TIMER_STATS
  465.  
  466. extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
  467.                      void *timerf, char *comm,
  468.                      unsigned int timer_flag);
  469.  
  470. static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
  471. {
  472.     timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
  473.                  timer->function, timer->start_comm, 0);
  474. }
  475.  
  476. extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer,
  477.                          void *addr);
  478.  
  479. static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
  480. {
  481.     __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0));
  482. }
  483.  
  484. static inline void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
  485. {
  486.     timer->start_site = NULL;
  487. }
  488. #else
  489. static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
  490. {
  491. }
  492.  
  493. static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
  494. {
  495. }
  496.  
  497. static inline void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
  498. {
  499. }
  500. #endif
  501.  
  502. #endif
  503.